package com.mazewei.dev.service;

import com.mazewei.dev.dao.CourseDao;
import com.mazewei.dev.entity.Course;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 课程匹配服务
 * 负责处理课程名称的匹配、格式化和编号生成
 */
@Service
public class CourseMatchingService {
    
    private static final Logger logger = LoggerFactory.getLogger(CourseMatchingService.class);
    
    @Autowired
    private CourseDao courseDao;
    
    @Autowired
    private GradeExtractionService gradeExtractionService;
    
    /**
     * 根据课程名称和班级名称获取课程编号
     * @param subjectName 课程名称
     * @param className 班级名称
     * @return 课程编号
     */
    public String getCourseCodeWithGrade(String subjectName, String className) {
        if (subjectName == null || subjectName.trim().isEmpty()) {
            logger.warn("[课程匹配失败] 科目名称为空");
            return "";
        }
        
        logger.info("[课程匹配开始] 科目: {}, 班级: {}", subjectName, className);
        
        // 特殊调试：道德与法治课程
        if (subjectName.contains("道德与法治")) {
            logger.info("[道德与法治调试] 检测到道德与法治课程，开始详细匹配过程");
            logger.info("[道德与法治调试] 原始科目名称: [{}]", subjectName);
            logger.info("[道德与法治调试] 班级名称: [{}]", className);
        }
        
        try {
            // 步骤1: 优先使用原始科目名称进行精确匹配
            // 步骤1.0: 优先处理艺术类课程的直接转换和匹配
            String gradeIdentifierForArt = gradeExtractionService.extractGradeIdentifier(className);
            logger.info("[艺术类课程调试] 班级名称: {}, 提取的年级标识符: {}", className, gradeIdentifierForArt);
            
            if (gradeIdentifierForArt != null && !gradeIdentifierForArt.isEmpty()) {
                String baseArtSubject = null;

                // 精确匹配艺术类课程名称
                if (subjectName.equals("艺术（音乐）") || subjectName.equals("艺术(音乐)")) {
                    baseArtSubject = "音乐";
                    logger.info("[艺术类课程调试] 检测到音乐课程: {}", subjectName);
                } else if (subjectName.equals("艺术（美术）") || subjectName.equals("艺术(美术)")) {
                    baseArtSubject = "美术";
                    logger.info("[艺术类课程调试] 检测到美术课程: {}", subjectName);
                } else if (subjectName.equals("艺术（舞蹈）") || subjectName.equals("艺术(舞蹈)")) {
                    baseArtSubject = "舞蹈";
                    logger.info("[艺术类课程调试] 检测到舞蹈课程: {}", subjectName);
                } else if (subjectName.equals("艺术（健美操）") || subjectName.equals("艺术(健美操)")) {
                    // 健美操属于体育类，不在艺术类处理范围内
                    logger.info("[艺术类课程调试] 检测到健美操课程，跳过艺术类处理: {}", subjectName);
                    baseArtSubject = null; // 明确设置为null，跳过艺术类处理
                }

                if (baseArtSubject != null) {
                    // 构造目标课程名称：音乐（一上）、美术（一上）、舞蹈（一上）等
                    String artSubjectNameToMatch = baseArtSubject + gradeIdentifierForArt;
                    logger.info("[艺术类课程优先匹配] 原始科目: {}, 目标基础科目: {}, 年级标识: {}, 尝试匹配: {}", subjectName, baseArtSubject, gradeIdentifierForArt, artSubjectNameToMatch);
                    
                    Course course = courseDao.findByName(artSubjectNameToMatch);
                    if (course != null && course.getCourNum() != null) {
                        logger.info("[课程匹配成功] 艺术类优先匹配 - 科目: {} -> 编号: {}", artSubjectNameToMatch, course.getCourNum());
                        return course.getCourNum();
                    } else {
                        logger.warn("[艺术类课程匹配失败] 未找到课程: {}, course对象: {}", artSubjectNameToMatch, course);
                    }
                    
                    // 尝试转换括号格式：中文括号 <-> 英文括号
                    String alternativeArtSubjectName = convertBracketFormat(artSubjectNameToMatch);
                    if (!alternativeArtSubjectName.equals(artSubjectNameToMatch)) {
                        logger.info("[艺术类课程优先匹配] 尝试转换括号格式匹配: {}", alternativeArtSubjectName);
                        course = courseDao.findByName(alternativeArtSubjectName);
                        if (course != null && course.getCourNum() != null) {
                            logger.info("[课程匹配成功] 艺术类优先匹配 (转换括号) - 科目: {} -> 编号: {}", alternativeArtSubjectName, course.getCourNum());
                            return course.getCourNum();
                        } else {
                            logger.warn("[艺术类课程匹配失败] 转换括号后仍未找到课程: {}, course对象: {}", alternativeArtSubjectName, course);
                        }
                    }
                    
                    logger.warn("[艺术类课程匹配失败] 未找到匹配的课程: {} 或 {}", artSubjectNameToMatch, alternativeArtSubjectName);
                    // 艺术类课程匹配失败，继续后续匹配逻辑
                }
            }

            // 步骤1: 尝试原始科目名称精确匹配
            logger.debug("[步骤1] 尝试原始科目名称精确匹配: {}", subjectName);
            Course course = courseDao.findByName(subjectName);
            if (course != null && course.getCourNum() != null) {
                logger.info("[课程匹配成功] 原始名称精确匹配 - 科目: {} -> 编号: {}", subjectName, course.getCourNum());
                return course.getCourNum();
            }
            logger.debug("[步骤1失败] 数据库中未找到原始科目: {}", subjectName);
            
            // 步骤1.5: 尝试不同括号格式的匹配（解决数据库中圆括号vs中文括号的问题）
            String alternativeName = convertBracketFormat(subjectName);
            if (!alternativeName.equals(subjectName)) {
                logger.debug("[步骤1.5] 尝试转换括号格式: {} -> {}", subjectName, alternativeName);
                course = courseDao.findByName(alternativeName);
                if (course != null && course.getCourNum() != null) {
                    logger.info("[课程匹配成功] 括号格式转换匹配 - 科目: {} -> 编号: {}", alternativeName, course.getCourNum());
                    return course.getCourNum();
                }
            }
            
            // 步骤1.6: 特殊处理体育课程，尝试添加年级标识
            if (subjectName.matches("体育[一二三四五六]\\([^)]+\\)")) {
                logger.debug("[步骤1.6] 检测到体育课程，尝试添加年级标识: {}", subjectName);
                String gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);
                if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                    // 尝试原始格式 + 年级标识
                    String nameWithGrade = subjectName + gradeIdentifier;
                    logger.debug("[步骤1.6] 尝试体育课程+年级: {}", nameWithGrade);
                    course = courseDao.findByName(nameWithGrade);
                    if (course != null && course.getCourNum() != null) {
                        logger.info("[课程匹配成功] 体育课程+年级匹配 - 科目: {} -> 编号: {}", nameWithGrade, course.getCourNum());
                        return course.getCourNum();
                    }
                    
                    // 尝试转换括号格式 + 年级标识
                    String alternativeWithGrade = convertBracketFormat(subjectName) + gradeIdentifier;
                    logger.debug("[步骤1.6] 尝试体育课程括号转换+年级: {}", alternativeWithGrade);
                    course = courseDao.findByName(alternativeWithGrade);
                    if (course != null && course.getCourNum() != null) {
                        logger.info("[课程匹配成功] 体育课程括号转换+年级匹配 - 科目: {} -> 编号: {}", alternativeWithGrade, course.getCourNum());
                        return course.getCourNum();
                    }
                }
            }
            
            // 步骤2: 如果原名无法匹配，尝试添加班级标签进行匹配（特殊情况特殊处理）
            List<String> possibleCourseNames = generatePossibleCourseNames(subjectName, className);
            
            // 特殊处理体育课程和健美操课程
            if (subjectName.matches("体育[一二三四五六]\\([^)]+\\)") || subjectName.contains("健美操")) {
                logger.info("[特殊处理] 检测到体育/健美操课程: {}, 班级: {}", subjectName, className);
                // 获取数据库中所有课程，进行详细日志记录
                List<Course> allCourses = courseDao.findAll();
                logger.info("[特殊处理] 数据库中共有{}个课程", allCourses.size());
                
                // 记录所有可能的匹配项
                for (Course c : allCourses) {
                    if (c.getCourName() != null && (c.getCourName().contains("体育") || c.getCourName().contains("健美操"))) {
                        if (subjectName.contains("健美操") && c.getCourName().contains("健美操")) {
                            logger.info("[特殊处理] 数据库中的健美操相关课程: {} -> {}", c.getCourName(), c.getCourNum());
                        } else if (c.getCourName().contains("乒乓球")) {
                            logger.info("[特殊处理] 数据库中的相关课程: {} -> {}", c.getCourName(), c.getCourNum());
                        }
                    }
                }
                
                // 记录所有生成的可能课程名称
                logger.info("[特殊处理] 生成了{}个可能的课程名称:", possibleCourseNames.size());
                for (String name : possibleCourseNames) {
                    logger.info("[特殊处理] 可能的课程名称: {}", name);
                }
            }
            
            for (String possibleName : possibleCourseNames) {
                logger.debug("[步骤2] 尝试可能的课程名称: {}", possibleName);
                
                // 对每个可能的名称也尝试不同的括号格式
                String[] namesToTry = {possibleName, convertBracketFormat(possibleName)};
                for (String nameToTry : namesToTry) {
                    logger.debug("[步骤2] 尝试可能的课程名称（含括号转换）: {}", nameToTry);
                    course = courseDao.findByName(nameToTry);
                    if (course != null && course.getCourNum() != null) {
                        logger.info("[课程匹配成功] 可能名称匹配 - 科目: {} -> 编号: {}", nameToTry, course.getCourNum());
                        return course.getCourNum();
                    }
                }
            }
            
            // 步骤3: 如果精确匹配失败，尝试模糊匹配
            logger.debug("[步骤3] 开始模糊匹配");
            List<Course> allCourses = courseDao.findAll();
            
            // 首先尝试基于班级的智能匹配
            String gradeLevel = gradeExtractionService.extractGradeFromClassName(className);
            logger.debug("[步骤3] 从班级名称提取的年级: {}", gradeLevel);
            
            // 特殊调试：道德与法治课程
            if (subjectName.contains("道德与法治")) {
                logger.info("[道德与法治调试] 步骤3开始，提取的年级: [{}]", gradeLevel);
                logger.info("[道德与法治调试] 数据库中所有道法相关课程:");
                for (Course c : allCourses) {
                    if (c.getCourName() != null && c.getCourName().contains("道法")) {
                        logger.info("[道德与法治调试]   {} -> {}", c.getCourNum(), c.getCourName());
                    }
                }
            }
            
            // 学段过滤：根据班级年级确定学段，避免跨学段匹配
            boolean isPrimary = gradeExtractionService.isPrimaryGrade(className);
            boolean isMiddle = gradeExtractionService.isMiddleGrade(className);
            logger.debug("[步骤3] 班级学段判断 - 小学: {}, 中学: {}", isPrimary, isMiddle);
            
            // 第一轮：优先匹配包含年级信息且学段正确的课程
            for (Course c : allCourses) {
                if (c.getCourName() != null) {
                    // 学段过滤：根据课程编号前缀判断学段
                    String courseCode = c.getCourNum();
                    boolean isCourseForPrimary = courseCode != null && courseCode.startsWith("p"); // 小学课程以p开头
                    boolean isCourseForMiddle = courseCode != null && courseCode.startsWith("j"); // 中学课程以j开头
                    
                    // 如果班级是小学但课程是中学的，或者班级是中学但课程是小学的，跳过
                    if ((isPrimary && isCourseForMiddle) || (isMiddle && isCourseForPrimary)) {
                        continue;
                    }
                    
                    // 优先匹配包含年级信息的课程
                    if (gradeLevel != null && c.getCourName().contains(gradeLevel)) {
                        // 特殊处理道德与法治课程：优先匹配标准格式（不带数字），且优先选择ppo101
                        if (subjectName.contains("道德与法治") && c.getCourName().contains("道法") && !c.getCourName().matches(".*道法\\d+.*")) {
                            // 优先返回ppo101编号
                            if ("ppo101".equals(c.getCourNum())) {
                                logger.info("[课程匹配成功] 道德与法治优先标准格式匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                                return c.getCourNum();
                            }
                        }
                        // 普通课程匹配
                        else if (c.getCourName().contains(subjectName) || subjectName.contains(c.getCourName())) {
                            logger.info("[课程匹配成功] 年级智能匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                            return c.getCourNum();
                        }
                    }
                }
            }
            
            // 如果标准格式道德与法治课程没找到，再尝试带数字的格式
            if (subjectName.contains("道德与法治")) {
                for (Course c : allCourses) {
                    if (c.getCourName() != null) {
                        // 学段过滤
                        String courseCode = c.getCourNum();
                        boolean isCourseForPrimary = courseCode != null && courseCode.startsWith("p");
                        boolean isCourseForMiddle = courseCode != null && courseCode.startsWith("j");
                        
                        if ((isPrimary && isCourseForMiddle) || (isMiddle && isCourseForPrimary)) {
                            continue;
                        }
                        
                        if (gradeLevel != null && c.getCourName().contains(gradeLevel) && c.getCourName().contains("道法")) {
                            logger.info("[课程匹配成功] 道德与法治备选格式匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                            return c.getCourNum();
                        }
                    }
                }
            }
            
            // 第二轮：如果年级智能匹配失败，进行学段过滤的模糊匹配
            // 特殊处理：对于"体育三(乒乓球)"这类课程，禁止直接匹配到"乒乓球"
            for (Course c : allCourses) {
                if (c.getCourName() != null) {
                    // 学段过滤：根据课程编号前缀判断学段
                    String courseCode = c.getCourNum();
                    boolean isCourseForPrimary = courseCode != null && courseCode.startsWith("p"); // 小学课程以p开头
                    boolean isCourseForMiddle = courseCode != null && courseCode.startsWith("j"); // 中学课程以j开头
                    
                    // 如果班级是小学但课程是中学的，或者班级是中学但课程是小学的，跳过
                    if ((isPrimary && isCourseForMiddle) || (isMiddle && isCourseForPrimary)) {
                        logger.debug("[学段过滤] 跳过不匹配学段的课程: {} (课程编号: {})", c.getCourName(), courseCode);
                        continue;
                    }
                    
                    // 检查是否为特殊体育课程格式（如"体育三(乒乓球)"）
                    if (subjectName.matches("体育[一二三四五六]\\([^)]+\\)")) {
                        // 对于体育课程，只匹配完整的课程名称，不允许部分匹配
                        if (c.getCourName().contains(subjectName)) {
                            logger.info("[课程匹配成功] 体育课程完整匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                            return c.getCourNum();
                        }
                        // 尝试括号格式转换后的匹配
                        String alternativeSubject = convertBracketFormat(subjectName);
                        if (!alternativeSubject.equals(subjectName) && c.getCourName().contains(alternativeSubject)) {
                            logger.info("[课程匹配成功] 体育课程括号转换匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                            return c.getCourNum();
                        }
                    } else {
                        // 特殊处理道德与法治课程：优先匹配道法格式，且优先选择ppo101
                        if (subjectName.contains("道德与法治")) {
                            // 检查是否匹配道法课程，优先选择ppo101
                            if (c.getCourName().contains("道法") && "ppo101".equals(c.getCourNum())) {
                                logger.info("[课程匹配成功] 道德与法治->道法优先匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                                return c.getCourNum();
                            }
                        }
                        
                        // 特殊处理艺术类课程：精确匹配转换后的名称
                        if (subjectName.equals("艺术（音乐）") || subjectName.equals("艺术(音乐)")) {
                            if (c.getCourName().contains("音乐")) {
                                logger.info("[课程匹配成功] 艺术音乐匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                                return c.getCourNum();
                            }
                        }
                        if (subjectName.equals("艺术（美术）") || subjectName.equals("艺术(美术)")) {
                            if (c.getCourName().contains("美术")) {
                                logger.info("[课程匹配成功] 艺术美术匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                                return c.getCourNum();
                            }
                        }
                        if (subjectName.equals("艺术（舞蹈）") || subjectName.equals("艺术(舞蹈)")) {
                            if (c.getCourName().contains("舞蹈")) {
                                logger.info("[课程匹配成功] 艺术舞蹈匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                                return c.getCourNum();
                            }
                        }
                        
                        // 对于非特殊体育课程，使用学段过滤的模糊匹配逻辑
                        if (c.getCourName().contains(subjectName) || subjectName.contains(c.getCourName())) {
                            logger.info("[课程匹配成功] 学段过滤模糊匹配 - 科目: {} -> 编号: {} (匹配: {})", subjectName, c.getCourNum(), c.getCourName());
                            return c.getCourNum();
                        }
                    }
                }
            }
            
            // 步骤4: 如果所有匹配都失败，返回空字符串
            logger.warn("[课程匹配失败] 未找到课程: {}", subjectName);
            return "";
            
        } catch (Exception e) {
            logger.error("[课程匹配异常] 查询课程编号时发生错误: {}", subjectName, e);
            return "";
        }
    }
    
    /**
     * 格式化课程名称（根据班级名称添加年级标识）
     * @param subjectName 原始课程名称
     * @param className 班级名称
     * @return 格式化后的课程名称
     */
    public String formatSubjectName(String subjectName, String className) {
        if (subjectName == null || subjectName.trim().isEmpty()) {
            return "";
        }
        
        // 如果已经包含年级信息（中文或英文括号），直接返回
        if ((subjectName.contains("（") && subjectName.contains("）")) || 
            (subjectName.contains("(") && subjectName.contains(")"))) {
            return subjectName;
        }
        
        // 首先对课程名称进行标准化处理，确保去除数字后缀
        String standardizedSubjectName = convertSubjectNameOnRead(subjectName);
        
        // 处理特殊课程名称
        String processedSubjectName = standardizedSubjectName;
        
        // 综合实践活动 -> 综合实践
        if (subjectName.contains("综合实践活动")) {
            processedSubjectName = "综合实践";
        }
        
        // 处理艺术类课程：转换为数据库中的标准名称
        if (subjectName.equals("艺术（音乐）") || subjectName.equals("艺术(音乐)")) {
            String gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);
            return "音乐" + gradeIdentifier;
        }
        if (subjectName.equals("艺术（美术）") || subjectName.equals("艺术(美术)")) {
            String gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);
            return "美术" + gradeIdentifier;
        }
        if (subjectName.equals("艺术（舞蹈）") || subjectName.equals("艺术(舞蹈)") || subjectName.matches("艺术\\(舞蹈\\).*")) {
            String gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);
            return "舞蹈" + gradeIdentifier;
        }
        if (subjectName.equals("艺术（书法）") || subjectName.equals("艺术(书法)")) {
            String gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);
            return "书法" + gradeIdentifier;
        }
        
        // 根据班级名称提取年级标识
        String gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);
        
        // 确保使用中文括号，并且确保是上学期标识
        gradeIdentifier = gradeIdentifier.replace("(", "（").replace(")", "）");
        
        // 确保年级标识符是上学期格式，移除任何数字后缀
        if (gradeIdentifier.matches(".*（\\d+）.*")) {
            // 如果包含数字后缀，根据班级重新生成正确的年级标识
            gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);
        }
        
        // 所有课程统一使用中文括号格式（一上）、（二上）等
        
        // 数学、音乐、美术、舞蹈、书法、道法等使用中文括号以匹配数据库格式
        if (processedSubjectName.equals("数学") || processedSubjectName.equals("音乐") || 
            processedSubjectName.equals("美术") || processedSubjectName.equals("舞蹈") || 
            processedSubjectName.equals("书法") || processedSubjectName.equals("道法")) {
            // 将英文括号转换为中文括号
            String chineseGradeIdentifier = gradeIdentifier.replace("(", "（").replace(")", "）");
            return processedSubjectName + chineseGradeIdentifier;
        }
        
        // 道德与法治课程特殊处理：转换为道法+年级标识
        if (processedSubjectName.equals("道德与法治")) {
            logger.info("[道德与法治调试] formatSubjectName中检测到道德与法治，转换为道法格式");
            String chineseGradeIdentifier = gradeIdentifier.replace("(", "（").replace(")", "）");
            return "道法" + chineseGradeIdentifier;
        }
        
        // 默认情况下使用中文括号
        String chineseGradeIdentifier = gradeIdentifier.replace("(", "（").replace(")", "）");
        return processedSubjectName + chineseGradeIdentifier;
    }
    
    /**
     * 格式化课程名称（兼容旧版本，使用默认年级标识）
     * @param subjectName 原始课程名称
     * @return 格式化后的课程名称
     */
    public String formatSubjectName(String subjectName) {
        if (subjectName == null || subjectName.trim().isEmpty()) {
            return "";
        }
        
        // 如果已经包含年级信息，直接返回
        if (subjectName.contains("（") && subjectName.contains("）")) {
            return subjectName;
        }
        
        // 默认添加（一上）
        return subjectName + "（一上）";
    }
    
    /**
     * 生成可能的课程名称变体
     * @param subjectName 原始课程名称
     * @param className 班级名称
     * @return 可能的课程名称列表
     */
    private List<String> generatePossibleCourseNames(String subjectName, String className) {
        List<String> possibleNames = new ArrayList<>();
        
        if (subjectName == null || subjectName.trim().isEmpty()) {
            return possibleNames;
        }
        
        String originalSubject = subjectName.trim();
        
        // 特殊课程处理：少先队活动课、综合实践、舞蹈、艺术等
        String gradeIdentifier = gradeExtractionService.extractGradeIdentifier(className);

        if (originalSubject.startsWith("艺术（音乐）") || originalSubject.startsWith("艺术(音乐)")) {
            logger.debug("[特殊课程] 检测到艺术（音乐）课程: {}", originalSubject);
            possibleNames.add("音乐"); // 添加不带年级的，以防万一
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("音乐" + gradeIdentifier); // 例如 音乐（一上）
                possibleNames.add("音乐" + convertBracketFormat(gradeIdentifier)); // 例如 音乐(一上)
            }
        } else if (originalSubject.startsWith("艺术（美术）") || originalSubject.startsWith("艺术(美术)")) {
            logger.debug("[特殊课程] 检测到艺术（美术）课程: {}", originalSubject);
            possibleNames.add("美术");
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("美术" + gradeIdentifier);
                possibleNames.add("美术" + convertBracketFormat(gradeIdentifier));
            }
        } else if (originalSubject.startsWith("艺术（舞蹈）") || originalSubject.startsWith("艺术(舞蹈)")) {
            logger.debug("[特殊课程] 检测到艺术（舞蹈）课程: {}", originalSubject);
            possibleNames.add("舞蹈");
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("舞蹈" + gradeIdentifier);
                possibleNames.add("舞蹈" + convertBracketFormat(gradeIdentifier));
            }
        } else if (originalSubject.contains("舞蹈") || originalSubject.contains("形体")) { // 处理单独的“舞蹈”或“形体”输入
             logger.debug("[特殊课程] 检测到舞蹈/形体课程: {}", originalSubject);
             possibleNames.add("舞蹈");
             possibleNames.add("形体");
             if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                 possibleNames.add("舞蹈" + gradeIdentifier);
                 possibleNames.add("形体" + gradeIdentifier);
                 possibleNames.add("舞蹈" + convertBracketFormat(gradeIdentifier));
                 possibleNames.add("形体" + convertBracketFormat(gradeIdentifier));
             }
        } else if (originalSubject.contains("少先队") || originalSubject.equals("少先队活动课")) {
            logger.debug("[特殊课程] 检测到少先队活动课: {}", originalSubject);
            possibleNames.add("少先队活动课");
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("少先队活动课" + gradeIdentifier);
            }
        } else if (originalSubject.contains("综合实践")) {
            logger.debug("[特殊课程] 检测到综合实践课程: {}", originalSubject);
            // 优先匹配标准格式（不带数字）
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                // 最优先匹配综合实践（年级）格式
                possibleNames.add("综合实践" + gradeIdentifier);
                possibleNames.add("综合实践活动" + gradeIdentifier);
            }
            // 基础名称也优先标准格式
            possibleNames.add("综合实践");
            possibleNames.add("综合实践活动");
        } else if (originalSubject.contains("舞蹈") || originalSubject.contains("形体") || originalSubject.contains("艺术(舞蹈)")) {
            logger.debug("[特殊课程] 检测到舞蹈/形体课程: {}", originalSubject);
            possibleNames.add("舞蹈");
            possibleNames.add("形体");
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("舞蹈" + gradeIdentifier);
                possibleNames.add("形体" + gradeIdentifier);
                possibleNames.add("舞蹈" + convertBracketFormat(gradeIdentifier));
                possibleNames.add("形体" + convertBracketFormat(gradeIdentifier));
            }
            // 处理艺术(舞蹈)格式
            if (originalSubject.contains("艺术(舞蹈)")) {
                String gradeId = gradeExtractionService.extractGradeIdentifier(className);
                possibleNames.add("舞蹈" + (gradeId != null ? gradeId : ""));
                possibleNames.add("形体" + (gradeId != null ? gradeId : ""));
            }
        } else if (originalSubject.contains("健美操")) {
            logger.debug("[特殊课程] 检测到健美操课程: {}", originalSubject);
            possibleNames.add("健美操");
            possibleNames.add("健美操社团");
            // 添加数据库中实际存在的健美操课程名称
            possibleNames.add("健美操（二上）");
            possibleNames.add("健美操(二上)");
            possibleNames.add("体育五（健美操校本课程）（三上）");
            possibleNames.add("体育五(健美操校本课程)(三上)");
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("健美操" + gradeIdentifier);
                possibleNames.add("健美操" + convertBracketFormat(gradeIdentifier));
                possibleNames.add("体育五（健美操校本课程）" + gradeIdentifier);
                possibleNames.add("体育五（健美操校本课程）" + convertBracketFormat(gradeIdentifier));
            }
        } else if (originalSubject.contains("书法")) {
            logger.debug("[特殊课程] 检测到书法课程: {}", originalSubject);
            // 优先匹配标准格式（不带数字）
            possibleNames.add("书法");
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("书法" + gradeIdentifier);
                possibleNames.add("书法" + convertBracketFormat(gradeIdentifier));
            }
            // 添加艺术（书法）和语文（书法）的变体
            possibleNames.add("艺术（书法）");
            possibleNames.add("语文（书法）");
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add("艺术（书法）" + gradeIdentifier);
                possibleNames.add("语文（书法）" + gradeIdentifier);
                possibleNames.add("艺术（书法）" + convertBracketFormat(gradeIdentifier));
                possibleNames.add("语文（书法）" + convertBracketFormat(gradeIdentifier));
            }
        } else if (originalSubject.contains("道德与法治")) {
            logger.info("[道德与法治调试] 在generatePossibleCourseNames中检测到道德与法治课程: {}", originalSubject);
            logger.info("[道德与法治调试] 提取的年级标识: [{}]", gradeIdentifier);
            
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                // 最优先匹配标准格式（不带数字）
                String nameWithGrade1 = "道法" + gradeIdentifier;
                String nameWithGrade2 = "道德与法治" + gradeIdentifier;
                possibleNames.add(nameWithGrade1);
                possibleNames.add(nameWithGrade2);
                
                // 转换括号格式：英文括号转中文括号，中文括号转英文括号
                String convertedGradeId = convertBracketFormat(gradeIdentifier);
                if (!convertedGradeId.equals(gradeIdentifier)) {
                    String nameWithConvertedGrade1 = "道法" + convertedGradeId;
                    String nameWithConvertedGrade2 = "道德与法治" + convertedGradeId;
                    possibleNames.add(nameWithConvertedGrade1);
                    possibleNames.add(nameWithConvertedGrade2);
                    logger.info("[道德与法治调试] 添加转换括号格式的名称: [{}], [{}]", nameWithConvertedGrade1, nameWithConvertedGrade2);
                }
                
                logger.info("[道德与法治调试] 添加带年级名称: [{}], [{}]", nameWithGrade1, nameWithGrade2);
            }
            
            // 基础名称
            possibleNames.add("道法");
            possibleNames.add("道德与法治");
            logger.info("[道德与法治调试] 添加基础名称: 道法, 道德与法治");
            logger.info("[道德与法治调试] 当前可能名称列表大小: {}", possibleNames.size());
        } else if (originalSubject.matches(".*（.*[上下]）.*")) {
            logger.debug("[特殊课程] 检测到特殊格式课程: {}", originalSubject);
            // 对于这种格式，尝试去掉括号内容
            String withoutBrackets = originalSubject.replaceAll("（.*?）", "").trim();
            if (!withoutBrackets.equals(originalSubject)) {
                possibleNames.add(withoutBrackets);
            }
            
            // 尝试替换括号内的年级标识
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                String withNewGrade = withoutBrackets + "（" + gradeIdentifier + "）";
                possibleNames.add(withNewGrade);
                
                // 也尝试上下学期的变体
                possibleNames.add(withoutBrackets + "（" + gradeIdentifier + "上）");
                possibleNames.add(withoutBrackets + "（" + gradeIdentifier + "下）");
            }
        } else if (originalSubject.matches("体育[一二三四五六]\\([^)]+\\)")) {
            // 特殊处理体育课程（如"体育三(乒乓球)"）
            logger.debug("[特殊课程] 检测到体育课程: {}", originalSubject);
            
            // 添加原始名称
            possibleNames.add(originalSubject);
            
            // 添加带年级标识的变体
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                possibleNames.add(originalSubject + gradeIdentifier);
                possibleNames.add(originalSubject + "（" + gradeIdentifier.replace("（", "").replace("）", "") + "上）");
                possibleNames.add(originalSubject + "（" + gradeIdentifier.replace("（", "").replace("）", "") + "下）");
            }
            
            // 尝试括号格式转换
            String alternativeFormat = convertBracketFormat(originalSubject);
            if (!alternativeFormat.equals(originalSubject)) {
                possibleNames.add(alternativeFormat);
                if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                    possibleNames.add(alternativeFormat + gradeIdentifier);
                    possibleNames.add(alternativeFormat + "（" + gradeIdentifier.replace("（", "").replace("）", "") + "上）");
                    possibleNames.add(alternativeFormat + "（" + gradeIdentifier.replace("（", "").replace("）", "") + "下）");
                }
            }
        } else {
            // 普通情况：尝试添加年级标识
            if (gradeIdentifier != null && !gradeIdentifier.isEmpty()) {
                // 直接添加年级标识
                possibleNames.add(originalSubject + gradeIdentifier);
                
                // 为所有课程同时生成中文和英文括号格式
                // 中文括号格式
                String chineseGradeId = gradeIdentifier.replace("(", "（").replace(")", "）");
                possibleNames.add(originalSubject + chineseGradeId);
                
                // 英文括号格式
                String englishGradeId = gradeIdentifier.replace("（", "(").replace("）", ")");
                possibleNames.add(originalSubject + englishGradeId);
                
                // 提取纯年级信息（去掉所有括号）
                String gradeOnly = gradeIdentifier.replace("（", "").replace("）", "").replace("(", "").replace(")", "");
                
                // 添加上下学期的变体（中文括号）
                possibleNames.add(originalSubject + "（" + gradeOnly + "上）");
                possibleNames.add(originalSubject + "（" + gradeOnly + "下）");
                
                // 添加上下学期的变体（英文括号）
                possibleNames.add(originalSubject + "(" + gradeOnly + "上)");
                possibleNames.add(originalSubject + "(" + gradeOnly + "下)");
                
                // 尝试数字年级格式 - 已注释掉以避免生成数字后缀的课程名称
                // String numericGrade = gradeExtractionService.convertGradeToNumeric(gradeIdentifier);
                // if (numericGrade != null && !numericGrade.equals(gradeIdentifier)) {
                //     possibleNames.add(originalSubject + numericGrade);
                //     // 数字年级的中文括号格式
                //     possibleNames.add(originalSubject + "（" + numericGrade + "）");
                //     possibleNames.add(originalSubject + "（" + numericGrade + "上）");
                //     possibleNames.add(originalSubject + "（" + numericGrade + "下）");
                //     // 数字年级的英文括号格式
                //     possibleNames.add(originalSubject + "(" + numericGrade + ")");
                //     possibleNames.add(originalSubject + "(" + numericGrade + "上)");
                //     possibleNames.add(originalSubject + "(" + numericGrade + "下)");
                // }
            }
            
            // 尝试常见的课程名称变体
            possibleNames.addAll(generateCommonSubjectVariants(originalSubject));
        }
        
        // 去除重复项
        return possibleNames.stream().distinct().collect(Collectors.toList());
    }
    
    /**
     * 生成常见的课程名称变体
     * @param subjectName 原始课程名称
     * @return 课程名称变体列表
     */
    private List<String> generateCommonSubjectVariants(String subjectName) {
        List<String> variants = new ArrayList<>();
        
        // 数学相关变体
        if (subjectName.contains("数学")) {
            variants.add("数学");
            variants.add("Mathematics");
            variants.add("Math");
        }
        
        // 语文相关变体
        if (subjectName.contains("语文")) {
            variants.add("语文");
            variants.add("Chinese");
            variants.add("中文");
        }
        
        // 英语相关变体
        if (subjectName.contains("英语")) {
            variants.add("英语");
            variants.add("English");
        }
        
        // 体育相关变体
        if (subjectName.contains("体育")) {
            variants.add("体育");
            variants.add("体育与健康");
            variants.add("PE");
            variants.add("Physical Education");
        }
        
        // 音乐相关变体
        if (subjectName.contains("音乐")) {
            variants.add("音乐");
            variants.add("Music");
        }
        
        // 美术相关变体
        if (subjectName.contains("美术")) {
            variants.add("美术");
            variants.add("Art");
            variants.add("艺术");
        }
        
        // 道德与法治相关变体
        if (subjectName.contains("道德与法治") || subjectName.contains("道法")) {
            variants.add("道德与法治");
            variants.add("道法");
        }
        
        // 书法相关变体
        if (subjectName.contains("书法")) {
            variants.add("书法");
            variants.add("艺术（书法）");
            variants.add("语文（书法）");
        }
        
        return variants;
    }
    
    /**
     * 转换括号格式：中文括号 <-> 英文括号
     * 解决数据库中课程名称括号格式不一致的问题
     * @param courseName 课程名称
     * @return 转换括号格式后的课程名称
     */
    private String convertBracketFormat(String courseName) {
        if (courseName == null || courseName.trim().isEmpty()) {
            return courseName;
        }
        
        // 如果包含中文括号，转换为英文括号
        if (courseName.contains("（") && courseName.contains("）")) {
            return courseName.replace("（", "(").replace("）", ")");
        }
        
        // 如果包含英文括号，转换为中文括号
        if (courseName.contains("(") && courseName.contains(")")) {
            return courseName.replace("(", "（").replace(")", "）");
        }
        
        // 如果没有括号或格式不匹配，返回原名称
        return courseName;
    }
    
    /**
     * 生成默认课程编号
     * 当数据库中找不到对应课程时，基于科目名称生成一个默认编号
     */
    private String generateDefaultCourseCode(String subjectName) {
        if (subjectName == null || subjectName.trim().isEmpty()) {
            return "";
        }
        
        // 特殊处理艺术类课程：不生成默认编号，而是继续正常匹配流程
        // 这些课程应该通过正常的匹配逻辑找到对应的数据库课程
        
        // 移除常见的后缀和前缀
        String cleanName = subjectName.trim()
            .replaceAll("课前准备$", "")
            .replaceAll("午读$", "")
            .replaceAll("^课程准备", "")
            .replaceAll("\\s+", "");
        
        if (cleanName.isEmpty()) {
            return "";
        }
        
        // 当找不到匹配项时，返回空字符串而不是生成默认编码
        return "";
    }
    
    /**
     * 转换课程名称格式（读取时使用）
     * @param subjectName 原始课程名称
     * @return 转换后的课程名称
     */
    public String convertSubjectNameOnRead(String subjectName) {
        if (subjectName == null || subjectName.trim().isEmpty()) {
            return subjectName;
        }
        
        String cleaned = subjectName.trim();
        
        // 处理"综合实践活动" -> "综合实践"
        if ("综合实践活动".equals(cleaned)) {
            return "综合实践";
        }
        
        // 处理"艺术（书法）" -> "书法"
        if ("艺术（书法）".equals(cleaned)) {
            return "书法";
        }
        
        // 处理带数字的课程名称，去除数字后缀
        // 语文1、语文2等 -> 语文
        if (cleaned.matches("语文\\d+")) {
            return "语文";
        }
        
        // 数学1、数学2等 -> 数学
        if (cleaned.matches("数学\\d+")) {
            return "数学";
        }
        
        // 英语1、英语2等 -> 英语
        if (cleaned.matches("英语\\d+")) {
            return "英语";
        }
        
        // 音乐1、音乐2等 -> 音乐
        if (cleaned.matches("音乐\\d+")) {
            return "音乐";
        }
        
        // 美术1、美术2等 -> 美术
        if (cleaned.matches("美术\\d+")) {
            return "美术";
        }
        
        // 体育1、体育2等 -> 体育
        if (cleaned.matches("体育\\d+")) {
            return "体育";
        }
        
        // 科学1、科学2等 -> 科学
        if (cleaned.matches("科学\\d+")) {
            return "科学";
        }
        
        // 书法1、书法2、书法12等 -> 书法
        if (cleaned.matches("书法\\d+")) {
            return "书法";
        }
        
        // 综合实践1、综合实践2等 -> 综合实践
        if (cleaned.matches("综合实践\\d+")) {
            return "综合实践";
        }
        
        // 道法1、道法2等 -> 道法
        if (cleaned.matches("道法\\d+")) {
            return "道法";
        }
        
        // 道德与法治1、道德与法治2等 -> 道德与法治
        if (cleaned.matches("道德与法治\\d+")) {
            return "道德与法治";
        }
        
        // 生物1、生物2等 -> 生物
        if (cleaned.matches("生物\\d+")) {
            return "生物";
        }
        
        // 历史1、历史2等 -> 历史
        if (cleaned.matches("历史\\d+")) {
            return "历史";
        }
        
        // 地理1、地理2等 -> 地理
        if (cleaned.matches("地理\\d+")) {
            return "地理";
        }
        
        // 物理1、物理2等 -> 物理
        if (cleaned.matches("物理\\d+")) {
            return "物理";
        }
        
        // 化学1、化学2等 -> 化学
        if (cleaned.matches("化学\\d+")) {
            return "化学";
        }
        
        // 信息技术1、信息技术2等 -> 信息技术
        if (cleaned.matches("信息技术\\d+")) {
            return "信息技术";
        }
        
        return cleaned;
    }
}